/**
 * 压缩图片到指定大小（80KB以内）
 * @param file 图片文件
 * @param maxSizeKB 最大文件大小（KB），默认80
 * @param callback 成功回调
 * @param onError 错误回调
 */
const compressImage = (
  file: Blob,
  maxSizeKB: number,
  callback: (base64Url: string) => void,
  onError?: (error: Error) => void
) => {
  const maxSize = maxSizeKB * 1024; // 转换为字节
  const reader = new FileReader();

  reader.onload = (e) => {
    const img = new Image();
    img.onload = () => {
      // 计算压缩后的尺寸（保持宽高比，最大宽度或高度为1920）
      const maxDimension = 1920;
      let width = img.width;
      let height = img.height;

      if (width > maxDimension || height > maxDimension) {
        if (width > height) {
          height = (height * maxDimension) / width;
          width = maxDimension;
        } else {
          width = (width * maxDimension) / height;
          height = maxDimension;
        }
      }

      // 创建canvas
      const canvas = document.createElement('canvas');
      canvas.width = width;
      canvas.height = height;
      canvas.style.backgroundColor = 'transparent';
      const ctx = canvas.getContext('2d');

      if (!ctx) {
        const error = new Error('无法创建canvas上下文');
        if (onError) {
          onError(error);
        } else {
          console.error(error);
        }
        return;
      }

      // 绘制图片
      ctx.drawImage(img, 0, 0, width, height);

      // 尝试不同的质量值，直到文件大小符合要求
      let quality = 0.9;
      let base64Url = '';
      let size = 0;

      const tryCompress = () => {
        base64Url = canvas.toDataURL('image/jpeg', quality);
        // 计算base64字符串的实际大小（减去data:image/jpeg;base64,前缀）
        const base64Data = base64Url.split(',')[1];
        if (!base64Data) {
          const error = new Error('Base64数据解析失败');
          if (onError) {
            onError(error);
          } else {
            console.error(error);
          }
          return;
        }
        size = (base64Data.length * 3) / 4;

        if (size > maxSize && quality > 0.1) {
          // 如果文件太大，降低质量继续尝试
          quality -= 0.1;
          tryCompress();
        } else if (size <= maxSize) {
          // 文件大小符合要求
          callback(base64Url);
        } else {
          // 即使质量降到最低也超过限制，进一步缩小尺寸
          if (width > 800 || height > 800) {
            width = Math.max(width * 0.8, 800);
            height = Math.max(height * 0.8, 800);
            canvas.width = width;
            canvas.height = height;
            ctx.drawImage(img, 0, 0, width, height);
            quality = 0.9;
            tryCompress();
          } else {
            // 已经是最小尺寸，使用最低质量
            base64Url = canvas.toDataURL('image/jpeg', 0.1);
            callback(base64Url);
          }
        }
      };

      tryCompress();
    };

    img.onerror = () => {
      const error = new Error('图片加载失败');
      if (onError) {
        onError(error);
      } else {
        console.error(error);
      }
    };

    if (e.target?.result) {
      img.src = e.target.result as string;
    }
  };

  reader.onerror = () => {
    const error = new Error('读取文件失败');
    if (onError) {
      onError(error);
    } else {
      console.error(error);
    }
  };

  reader.readAsDataURL(file);
};

/**
 * 获取图片的base64编码（自动压缩到80KB以内）
 * @param img 图片
 * @param callback 回调函数
 * @param onError 错误回调函数（可选）
 */
export const getBase64 = (
  img: Blob,
  callback: (base64Url: string) => void,
  onError?: (error: Error) => void
) => {
  compressImage(img, 80, callback, onError);
}
